package pe.gob.foncodes.ssa.bs.common.util;

import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import pe.gob.foncodes.ssa.bs.common.domain.Log;

public class StringHelper {

    /**
     * Agrega un nmero especfico de ceros a la cadena de texto. Dependiendo
     * del flagDirection, los posicionar a la derecha o izquierda de la cadena
     * de texto.
     * 
     * @param text
     *            cadena de texto
     * @param quantityOfZeros
     *            cantidad de ceros que se aumentarn a la cadena de texto
     * @param flgDirection
     *            <i>true</i> sita los ceros a la izquierda y <i>false</i>
     *            sita los ceros a la derecha de la cadena de texto
     * @return cadena de texto con ceros agregados
     */
    public synchronized static String fillZeros(String text,
            int quantityOfZeros, boolean flgDirection) {
        if (text == null) {
            text = "";
        }
        // Generating an specific quantity of zeros
        String zerosGenerated = "";
        for (int i = 0; i < quantityOfZeros; i++) {
            zerosGenerated = zerosGenerated + "0";
        }
        //
        if (flgDirection) {
            text = text + zerosGenerated;
        } else {
            text = zerosGenerated + text;
        }
        return text;
    }

    public static String capitalized(String str) {
        // first letter of each word in upper case.
        char ch;       // One of the characters in str.
        char prevCh;   // The character that comes before ch in the string.
        prevCh = ' ';  // separate each word.
        String result = "";
        for (int i = 0; i < str.length(); i++) {
            ch = str.charAt(i);
            if (Character.isLetter(ch) && (i == 0 || (prevCh == ' ' && !Character.isLetter(prevCh)))) {
                ch = Character.toUpperCase(ch);
            }
            prevCh = ch;  // prevCh for next iteration is ch.
            result += Character.toString(ch);
        }
        return result;
    }

    /**
     * Agrega un nmero especfico de ceros a la cadena de texto. Dependiendo
     * del flagDirection, los posicionar a la derecha o izquierda de la cadena
     * de texto.
     * 
     * @param number
     *            nmero al que se le agregarn los ceros
     * @param quantityOfZeros
     *            cantidad de ceros que se aumentarn al nmero
     * @param flgDirection
     *            <i>true</i> sita los ceros a la izquierda y <i>false</i>
     *            sita los ceros a la derecha del nmero
     * @return nmero con ceros agregados
     */
    public synchronized static String fillZeros(int number,
            int quantityOfZeros, boolean flgDirection) {
        String numberInText = number + "";
        // Generating an specific quantity of zeros
        String zerosGenerated = "";
        for (int i = 0; i < quantityOfZeros; i++) {
            zerosGenerated = zerosGenerated + "0";
        }
        //
        if (flgDirection) {
            numberInText = numberInText + zerosGenerated;
        } else {
            numberInText = zerosGenerated + numberInText;
        }
        return numberInText;
    }

    public synchronized static String reverseLines(String linesToInvert) {
        String linesInverted = "";
        String[] temp1 = linesToInvert.split("\r\n");
        String[] temp2 = new String[temp1.length];
        int x = 0;
        for (int i = temp1.length; i > 0; i--) {
            temp2[x] = temp1[i - 1];
            x++;
        }
        for (String string : temp2) {
            linesInverted = linesInverted + string + "\r\n";
        }
        return linesInverted;
    }

    public synchronized static String prependToEachLine(String linesToPrepend) {
        String linesPrepended = "";
        String[] temp1 = linesToPrepend.split("\r\n");
        int x = 0;
        for (String string : temp1) {
            if (!string.trim().startsWith("no")
                    && !string.trim().startsWith("shutdown")) {
                linesPrepended = linesPrepended + "no " + string + "\r\n";
            } else if (string.trim().startsWith("shutdown") || string.trim().startsWith("!")) {
                linesPrepended = linesPrepended + "\r\n";
            }
        }
        return linesPrepended;
    }

    public synchronized static String cleanBlankLines(String linesToClean) {
        String temp = "";
        String[] temp1 = linesToClean.split("\r\n");
        int x = 0;
        for (String string : temp1) {
            if (string != null && !string.trim().equals("")) {
                temp = temp + string + "\r\n";
            }
        }
        return temp;
    }

    public static String[] reSizeStringArray(String[] arreglo, String param) {
        String[] resultado = new String[arreglo.length + 1];
        for (int i = 0; i < arreglo.length; i++) {
            resultado[i] = arreglo[i];
        }
        resultado[arreglo.length] = param;
        return resultado;
    }

    public synchronized static String ordenBajaInterface(String descarga) {
        String lineas = descarga.substring(descarga.indexOf("interface"),
                descarga.indexOf("end") + 3);
        String[] temp1 = lineas.split("\r\n");
        String lineaInicial = temp1[0];
        String lineaFinal = temp1[temp1.length - 1];
        String temp = "";
        for (int i = 1; i < temp1.length - 1; i++) {
            temp = temp + temp1[i] + "\r\n";
        }
        temp = reverseLines(temp);
        temp = prependToEachLine(temp);
        temp = lineaInicial + "\r\nshutdown\r\n" + temp + "\r\n" + lineaFinal;
        temp = cleanBlankLines(temp);
        return temp;
    }

    public synchronized static boolean isCommandLineError(
            String commandLineAnswer) {
        String regularExpressions[] = {"*\\^*"};
        return false;
    }

    public static List<Log> parseLog(String log) {
        ArrayList<Log> logs = new ArrayList<Log>();
        String[] lineas = null;
        String[] temp = null;
        if (log != null && !log.equals("")) {
            lineas = log.split(Constante.LOG_SEPARA_FILA_RESPUESTA_ER);
            for (int i = 0; i < lineas.length; i++) {
                if (lineas[i] != null
                        && !lineas[i].equals("")
                        && lineas[i].indexOf(Constante.LOG_SEPARA_COLUMNA_RESPUESTA_ER) > -1) {
                    temp = lineas[i].split(Constante.LOG_SEPARA_COLUMNA_RESPUESTA_ER);
                    if (temp.length == 1) {
                        logs.add(new Log(temp[0], ""));
                    } else if (temp.length == 0) {//agregado por edwin 26022010
                        logs.add(new Log("", ""));	//fin agregado por edwin 26022010
                    } else {
                        logs.add(new Log(temp[0], temp[1]));
                    }
                }
            }
        }
        if (logs.isEmpty()) {
            logs = null;
        }
        return logs;
    }

    public static List<Long> ConvetLongArrayStringToListLong(List<Long> lista) {
        List<Long> listaTemp = new ArrayList<Long>();
        for (Object p : lista) {
            listaTemp.add(Long.valueOf(p.toString()));
        }
        return listaTemp;
    }

    public static boolean existeArray(String valor) {
        boolean existe = false;
        if (valor != null && !valor.equals("")) {
            int d = valor.indexOf(",");
            if (d > 0) {
                existe = true;
            }
        }
        return existe;
    }

    public static List<Long> ConvetStringArrayToListLong(String[] stringArray) {
        List<Long> longList = new ArrayList<Long>();
        for (String str : stringArray) {
            longList.add(new Long(str));
        }
        return longList;
    }

    public static List<String> ConvetStringArrayToListString(String[] stringArray) {
        List<String> longList = new ArrayList<String>();
        for (String str : stringArray) {
            longList.add(new String(str));
        }
        return longList;
    }

    /**
     * Completa un objeto con la cadena de texto enviada como parmetro hasta
     * que el objeto (el cual ser casteado a String) tenga que el sea igual al
     * enviado como parmetro. Dependiendo del flagDirection, se completar el
     * texto a la derecha o a la izquierda.
     * 
     * @param object
     *            Integer o String, el cual ser parseado a String
     * @param padding
     *            texto con un solo caracter (si tiene mas de uno, se coge solo
     *            el primero) que servir para completar el texto inicial
     * @param length
     *            tamao que tendr el texto final despus de completado
     * @param flagDirection
     *            true para completar el texto hacia la derecha y false para la
     *            izquieda
     * @return texto con contenido agregado a la derecha o izquierda
     */
    public static String fillContent(Object object, String padding, int length,
            boolean flagDirection) {
        String text = object.toString();
        if (text.length() >= length || padding == null) {
            return text;
        }
        if (padding.length() > 1) {
            padding = padding.substring(0, 1);
        }
        String newText = text;
        if (flagDirection) {
            for (int i = text.length(); i < length; i++) {
                newText = newText + padding;
            }
        } else {
            for (int i = text.length(); i < length; i++) {
                newText = padding + newText;
            }
        }
        return newText;
    }

    public boolean findStringInArray(String cadenaABuscar, String[] cadenas) {
        boolean respuesta = false;
        if (cadenas != null) {
            for (int i = 0; i < cadenas.length; i++) {
                if (cadenas[i] != null && !cadenas[i].trim().equals("")
                        && cadenas[i].trim().equals(cadenaABuscar)) {
                    respuesta = true;
                    break;
                }
            }
        }
        return respuesta;
    }

    public synchronized static String slotId(String cad) {
        String str = "";
        if (cad.split("/").length >= 2) {
            str = cad.split("/")[1];
        } else {
            str = null;
        }
        return str;
    }

    public synchronized static String extractSelectedLine(String sourceString, int indexLineToExtract) {
        int linea = indexLineToExtract;
        String resultado = null;
        String cadena = sourceString;
        String[] lineas = cadena.split("\n");
        if (lineas.length >= linea) {
            resultado = lineas[linea - 1];
        }
        return resultado;
    }

    /**
     * Devuelve un valor decimal segn el nmero de bits de un octeto.<br/>
     * <i><Por ejemplo : si se enva 6 (11111100), el mtodo devolver 252./i>
     * @param numberOfBits
     * @return valor decimal del octeto
     */
    public synchronized static Integer getDecimalValueFromOctetNumberOfBits(Integer numberOfBits) {
        Integer decimalValue = 0;
        int limit = 8 - numberOfBits;
        for (int i = 7; i >= limit; i--) {
            decimalValue = decimalValue + (int) Math.pow(2 * 1.0, i * 1.0);
        }
        return decimalValue;
    }

    public String[] getIpAndMaskFromRouteLine(String linea) {
        String[] ip = null;
        //linea = "ip route       200.37.36.32 255.255.255.224 GigabitEthernet0/1/0.2367 172.22.14.22";
        linea = linea.replaceFirst("ip route", "").trim();
        String[] resultados = linea.split(" {1,50}");
        ip = new String[]{resultados[2], resultados[3]};
        return ip;
    }

    public String[] getIpAndMaskFromPrefixLine(String linea) {
        String[] ip = null;
        //linea = "ip route       200.37.36.32 255.255.255.224 GigabitEthernet0/1/0.2367 172.22.14.22";
        linea = linea.replaceFirst("ip route", "").trim();
        String[] resultados = linea.split(" {1,50}");
        resultados = resultados[6].split("/");
        ip = new String[]{resultados[0], resultados[1]};
        return ip;
    }

    /**
     * @author TaT!
     * Devuelve el ip
     * del formato getLocalHost()
     * @param String
     */
    public static String dameMiIp(String host) {
        String ip = "";
        ip = host.substring(0, host.indexOf("/"));
        return ip;
    }

    /**
     * @author TaT!
     * Devuelve la estacion (Hostname)
     * del formato getLocalHost()
     * @param String
     */
    public static String dameMiHost(String host) {
        String hostName = "";
        hostName = host.substring(host.indexOf("/") + 1);
        return hostName;
    }

    /**
     * @author TaT!
     * Devuelve verdadero si la cadena base [base]
     * no contempla la cadena de comparacion [compareWith]
     * @param String
     */
    public static boolean validame(String base, String compareWith) {
        String cadena = compareWith.toUpperCase();
        String miCod = cadena;
        String tuCod = miCad(cadena, ",");

        for (int j = 0; j <= base.length(); j++) {
            if (!base.toUpperCase().contains(tuCod)) {
                miCod = reCad(miCod, ",");
                tuCod = miCad(miCod, ",");
            } else {
                return false;
            }
        }
        return true;
    }

    /**
     * @author TaT!
     * Devuelve el numero de veces que aparece
     * un caracter en una cadena
     *@param cadena, caracter
     */
    public static int frecuenciaCaracter(String cadena, String caracter) {
        int frecuencia = 0;
        for (int i = 0; i <= (cadena.length() - 1); i++) {
            if (String.valueOf(cadena.charAt(i)).equals(caracter)) {
                frecuencia++;
            }
        }
        return frecuencia;
    }

    /**
     * @author TaT!
     * Invierte la cadena recibida
     *@param sCadena
     */
    public static String invertirCadena(String sCadena) {
        String sCadenaInvertida = "";
        for (int x = sCadena.length() - 1; x >= 0; x--) {
            sCadenaInvertida = sCadenaInvertida + sCadena.charAt(x);
        }
        return sCadenaInvertida;
    }

    /**
     * @author TaT!
     * Devuelve verdadero si la cadena recibida
     * tiene numeros
     *@param cadena
     */
    public static boolean tieneNumeros(String cadena) {
        Pattern p = Pattern.compile("[0-9]");
        Matcher m = p.matcher(cadena);
        if (m.find()) {
            return true;
        }
        return false;
    }

    /**
     * @author TaT!
     * Devuelve verdadero si la cadena recibida
     * tiene letras
     *@param cadena
     */
    public static boolean tieneLetras(String cadena) {
        Pattern p = Pattern.compile("[A-Za-z]");
        Matcher m = p.matcher(cadena);
        if (m.find()) {
            return true;
        }
        return false;
    }

    /**
     * @author TaT!
     * Devuelve verdadero si la cadena recibida
     * tiene letras mayusculas
     *@param cadena
     */
    public static boolean tieneLetraMayuscula(String cadena) {
        Pattern p = Pattern.compile("[A-Z]");
        Matcher m = p.matcher(cadena);
        if (m.find()) {
            return true;
        }
        return false;
    }

    /**
     * @author TaT!
     * De una cadena separada por caracteres
     * devuelve la primera subcadena hasta antes del caracter
     * @param cadena, caracter
     */
    public static String miCad(String cadena, String caracter) {
        String miCadena = "";
        int i = cadena.indexOf(caracter);
        if (i != -1) {
            miCadena = cadena.substring(0, i);
        } else {
            miCadena = cadena;
        }
        return miCadena;
    }

    /**
     * @author TaT!
     * De una cadena separada por caracteres
     * devuelve la subcadena despues del primer caracter encontrado
     * hasta el fin de la cadena
     * @param cadena, caracter
     */
    public static String reCad(String cadena, String caracter) {
        String reCadena = "";
        int i = cadena.indexOf(caracter);
        if (i != -1) {
            reCadena = cadena.substring(i + 1, cadena.length());
        } else {
            reCadena = cadena;
        }
        return reCadena;
    }

    /**
     * Retorna FALSE cuando el texto es diferente de NULL y diferente de 
     * vacio. Caso contrario retorna TRUE;
     * @param valor texto que se evaluara, tipo String
     * @return TRUE o FALSE dependiendo de la condicion cumplida
     */
    public static boolean estaVacio(String valor) {
        if (valor != null && !valor.equals("") && !valor.equals("null")) {
            return false;
        }
        return true;
    }

    public static boolean estaVacioParametro(String valor) {
        if (valor == null || valor.equals("") || valor.equals("null")) {
            return true;
        }
        return false;
    }
}
